const { app, BrowserWindow, dialog } = require('electron');
const path = require('path');
const { spawn } = require('child_process');
const axios = require('axios');
const fs = require('fs');
const isDev = process.env.NODE_ENV === 'development';

// 尝试加载form-data模块
let FormData;
try {
  FormData = require('form-data');
  console.log('成功加载form-data模块');
} catch (error) {
  console.error('加载form-data模块失败:', error.message);
  // 继续执行，稍后处理
}

// 全局变量，用于存储Python后端进程
let pythonProcess = null;
let mainWindow = null;
let apiBaseUrl = 'http://localhost:8000/api';

// 创建主窗口
function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false,
    },
    icon: path.join(__dirname, '../public/icon.svg')
  });

  // 加载应用
  if (isDev) {
    // 开发环境下，加载开发服务器URL
    mainWindow.loadURL('http://localhost:3000');
    // 打开开发者工具
    mainWindow.webContents.openDevTools();
  } else {
    // 生产环境下，加载打包后的index.html
    mainWindow.loadFile(path.join(__dirname, '../dist/index.html'));
  }

  // 窗口关闭时触发
  mainWindow.on('closed', () => {
    mainWindow = null;
    stopPythonBackend();
  });
}

// 显示错误对话框
function showErrorDialog(title, message) {
  if (mainWindow) {
    dialog.showErrorBox(title, message);
  }
}

// 启动Python后端服务
function startPythonBackend() {
  // 检查Python后端是否已经在运行
  if (pythonProcess) {
    console.log('Python后端已经在运行');
    return;
  }

  try {
    let serverExecutable;
    let scriptPath;
    
    if (isDev) {
      // 开发环境：使用Python解释器
      const pythonExecutable = process.platform === 'win32' ? 'python' : 'python3';
      serverExecutable = pythonExecutable;
      scriptPath = path.join(app.getAppPath(), 'main.py');
      pythonProcess = spawn(serverExecutable, [scriptPath]);
    } else {
      // 生产环境：使用打包后的可执行文件
      const resourcesPath = process.resourcesPath;
      console.log('资源路径:', resourcesPath);
      
      // 尝试多个可能的路径
      const possiblePaths = [
        // 标准路径
        path.join(resourcesPath, 'medical_api_server', 'medical_api_server.exe'),
        // 替代路径 1
        path.join(resourcesPath, 'app.asar.unpacked', 'dist', 'medical_api_server', 'medical_api_server.exe'),
        // 替代路径 2
        path.join(app.getAppPath(), '..', 'medical_api_server', 'medical_api_server.exe'),
        // 替代路径 3
        path.join(app.getPath('exe'), '..', 'resources', 'medical_api_server', 'medical_api_server.exe'),
        // 替代路径 4 - 直接相对于应用程序目录
        path.join(path.dirname(app.getPath('exe')), 'resources', 'medical_api_server', 'medical_api_server.exe'),
        // 替代路径 5 - 绝对安装路径(典型的Windows安装路径)
        'C:\\Program Files\\集成医疗诊断平台\\resources\\medical_api_server\\medical_api_server.exe',
        // 替代路径 6 - 可能的x86安装路径
        'C:\\Program Files (x86)\\集成医疗诊断平台\\resources\\medical_api_server\\medical_api_server.exe'
      ];
      
      if (process.platform !== 'win32') {
        // 替换所有路径的.exe扩展名为空
        possiblePaths.forEach((p, i) => {
          possiblePaths[i] = p.replace('.exe', '');
        });
      }
      
      console.log('尝试查找服务器可执行文件，可能的路径:');
      possiblePaths.forEach(p => console.log(` - ${p}`));
      
      // 尝试所有可能的路径
      let found = false;
      for (const p of possiblePaths) {
        if (fs.existsSync(p)) {
          serverExecutable = p;
          found = true;
          console.log(`找到服务器可执行文件: ${serverExecutable}`);
          break;
        }
      }
      
      if (!found) {
        // 打印出资源目录内容，帮助诊断
        console.log('资源目录内容:');
        try {
          const resourcesDirContents = fs.readdirSync(resourcesPath);
          console.log(resourcesDirContents);
          
          // 如果存在medical_api_server目录，查看其内容
          const medicalServerDir = path.join(resourcesPath, 'medical_api_server');
          if (fs.existsSync(medicalServerDir)) {
            console.log('medical_api_server目录内容:');
            console.log(fs.readdirSync(medicalServerDir));
          }
        } catch (err) {
          console.error('无法读取资源目录:', err);
        }
        
        throw new Error(`找不到服务器可执行文件，尝试了以下路径: ${possiblePaths.join(', ')}`);
      }
      
      // 启动打包后的服务器
      pythonProcess = spawn(serverExecutable);
    }
    
    pythonProcess.stdout.on('data', (data) => {
      console.log(`Python后端输出: ${data}`);
    });
    
    pythonProcess.stderr.on('data', (data) => {
      console.error(`Python后端错误: ${data}`);
    });
    
    pythonProcess.on('close', (code) => {
      console.log(`Python后端进程退出，退出码 ${code}`);
      pythonProcess = null;
    });

    // 等待后端启动
    waitForBackendReady();
  } catch (error) {
    console.error('启动Python后端失败:', error);
    showErrorDialog('启动失败', `无法启动Python后端服务: ${error.message}`);
  }
}

// 等待后端准备就绪
function waitForBackendReady() {
  let attempts = 0;
  const maxAttempts = 30; // 最多尝试30次，每次间隔1秒
  
  const checkBackend = () => {
    attempts++;
    axios.get(`${apiBaseUrl}/`)
      .then(response => {
        console.log('后端服务已就绪:', response.data);
        if (mainWindow) {
          mainWindow.webContents.send('backend-ready', true);
        }
      })
      .catch(error => {
        console.log(`等待后端服务就绪 (${attempts}/${maxAttempts})...`);
        if (attempts < maxAttempts) {
          setTimeout(checkBackend, 1000);
        } else {
          console.error('后端服务启动失败:', error.message);
          if (mainWindow) {
            mainWindow.webContents.send('backend-ready', false);
            showErrorDialog('连接失败', '无法连接到Python后端服务，请确保Python环境已正确安装');
          }
        }
      });
  };
  
  // 开始检查
  setTimeout(checkBackend, 2000); // 先等待2秒再开始检查
}

// 停止Python后端服务
function stopPythonBackend() {
  if (pythonProcess) {
    console.log('停止Python后端...');
    try {
      if (process.platform === 'win32') {
        // Windows平台使用taskkill强制结束进程
        spawn('taskkill', ['/pid', pythonProcess.pid, '/f', '/t']);
      } else {
        // Unix平台使用kill信号
        pythonProcess.kill('SIGTERM');
      }
    } catch (error) {
      console.error('停止Python后端失败:', error);
    }
    pythonProcess = null;
  }
}

// 设置IPC通信 - 现在前端直接使用HTTP请求，不再需要IPC处理器
function setupIPC() {
  // 保持函数结构，但移除具体的IPC处理器
  console.log('前端直接使用HTTP请求，不再需要IPC通信');
}

// 应用准备就绪时
app.whenReady().then(() => {
  createWindow();
  setupIPC();
  startPythonBackend();

  // 在macOS上，当所有窗口关闭时，重新创建一个窗口
  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) {
      createWindow();
    }
  });
});

// 当所有窗口关闭时退出应用
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    stopPythonBackend();
    app.quit();
  }
});

// 应用退出前
app.on('before-quit', () => {
  stopPythonBackend();
});